Data processing system and method for protecting data in a data memory against an undetected change

ABSTRACT

A method for protecting data in a data memory against an undetected change, wherein a functional variable x is encoded via a value, an input constant, an input signature and a timestamp D into a coded variable, where the functional variable is normalized relative to a base to form the integer value from the functional variable.

BACKGROUND OF THE INVENTION 1. Field of the Invention

The invention relates to a data processing system and a method for protecting the data stored in a data memory against an undetected change.

2. Description of the Related Art

In safety-related applications, it is common practice to use variables in coded form so that they can be protected against errors and undetected modification. During an arithmetic coding process, a functional variable x is expanded by different check bits that enable specific errors that have occurred to be detected. An extended form of arithmetic coding is the ANBD encoding scheme. In ANBD encoding, an uncoded functional variable x is converted via an input constant A, a variable-specific input signature B_(x) and a timestamp D into a coded variable x_(c). x _(c) =A*x+B _(x) +D  Eq. 1

The input constant A enables errors in the value range to be detected. The use of a variable-specific input signature B_(x) enables operand and operator errors to be detected. The use of a timestamp D enables an unperformed update of the variable to be detected.

In the application, the coded variable x_(c) is used throughout in this case, because a decoding of the variable into the uncoded form x would lead to the loss of the error information present in the coded variable x_(c). In order to perform computational operations with a coded variable x_(c), it is necessary to use coded operators that include not only the functional part x, but also the associated check bits in the operation.

EP 3 104 276 A1 describes a method that enables an AND-encoded variable x_(c) to be recoded into an A′NB′D′-encoded variable x_(c)′, i.e., the check bits A, B and D to be replaced by the check bits A′, B′ and D′, without at the same time decoding the coded variable in one of the intermediate steps.

A disadvantageous aspect of ANBD encoding is that realizing floating-point arithmetic in this encoding scheme is very complicated and time-consuming. Thus, in accordance with the present state of the art, floating-point numbers (also known, inter alia, as reals or floats) are not processed explicitly as a data type in purely software-based safety-related applications. In accordance with the present state of the art, a particular solution approach in integer arithmetic (also known, inter alia, as integers) must be found for each requirement. In safety-related applications, it should be noted in this regard that it is not the mean but the maximum error of a calculation that is relevant. For this reason, the property of floating-point arithmetic, i.e., a value is always calculated with maximum precision, is not relevant in safety-related applications, but leads in ANBD-encoded processing of the data type to a computing time that is orders of magnitude longer than the computing time elapsing in the case of uncoded processing. Using a fixed-point arithmetic is not an alternative, because it does not allow the desired precision, in particular for more complex processing operations.

SUMMARY OF THE INVENTION

It is therefore an object of the invention to provide a representation of the data that allows a comparable application flexibility to floating-point arithmetic but requires fewer computing steps.

This and other objects and advantages are achieved in accordance with the invention by a method for protecting data in a data memory against an undetected change. A modification of the data can therefore be detected via the method. In this case, a functional variable x is encoded via a value value_(x), an input constant A, an input signature B_(x) and a timestamp D into a coded variable x_(c) in accordance with the following relationship: x _(c):=value_(x) *A+B _(x) +D.  Eq. 2

The method is characterized in that the functional variable x is normalized relative to a base Base_(x) to form the integer value value_(X) from the functional variable x. In other words, a functional variable x is converted into an ANBD-encoded variable x_(c), where the functional variable is normalized to a base Base_(x). This means that the functional variable x is represented within the coded variable x_(c) as value_(x), which is an integer multiple of the base Base_(X). The base Base_(X) is therefore the unit in which the functional variable x is represented. Accordingly, a functional variable x present as a floating-point number is reproduced in the coded variable as a functional component via an integer value_(x). The advantage resulting from this is that operations relating to the functional variable x may be performed in integer arithmetic. In this way, the maximum error in operations and the required computational overhead are reduced in comparison with floating-point arithmetic. At the same time, the flexibility is not limited with respect to the value range compared to the floating-point representation. The calculations are therefore performed with a higher degree of precision in the intermediate results and a subsequent rounding. As a result of the method, the duration of a coded processing operation is increased by a factor compared to uncoded processing. This factor lies significantly below the several orders of magnitude by which the duration increases when using coded floating-point numbers compared to uncoded processing.

In an embodiment of the method, the functional variable x is encoded during a compilation operation to yield the coded variable x_(c). In other words, the functional variable x is encoded during the binary number generation, for example in the compiler, into the coded variable x_(c). The encoding and in particular the normalization to a fixed base are therefore already performed at the time of the code generation. The advantage resulting from this is that the computing time can be reduced during the execution of the program because it is no longer necessary to establish a base during the runtime of a program.

In an embodiment, the value value_(x) is calculated in accordance with the following relationship: value_(x):=(x/Base_(x))mod(2)^(Sizex).  Eq. 3

In other words, the functional variable x is divided by the base Base_(x), where a remainder of the division is discarded. Size_(x) is the number of possible states or the available memory. This may be specified by the available number of bits n for storing a single value, that is to say, be equal, e.g., to a value 2^(n)=2¹⁶ where n=16 bits. The advantage resulting from this is that the value value_(x) is present as an integer. It is therefore possible to convert a floating-point number into an integer.

In another embodiment of the invention, the value value_(x) is formed by subtracting a smallest attainable value min_(x) of the functional variable x, which smallest attainable value is predefined according to a control program, from the functional variable x before the smallest attainable value is divided by the base Base_(x), the remainder being discarded, i.e., value_(x):=(x−min_(x)/Base_(x))mod(2)^(Sizex)  Eq. 4

The value min_(x) may be determined in uncoded form in a test run of the control program.

This results in the advantage that the value range is limited to the predefined value range.

In another embodiment, the data is provided for a control program and the base Base_(x) is calculated to a value greater than or equal to the difference between a greatest attainable value max_(x) predefined in accordance with the control program for the value x and a smallest attainable value min_(x) of the value x, divided by the size of the available memory, i.e., Base_(x)≥(max_(x)−min_(x))/Size_(x)  Eq. 5

In other words, the base Base_(x) represents the smallest possible unit into which the attainable value range can be subdivided. Two advantages are produced as a result of this step: Because the base is determined relative to the entire attainable value range, an overflow of values is excluded. Put differently, a value is prevented from exceeding the maximum value and consequently being unable to be represented. Because the base assumes the smallest possible value, the greatest possible precision is provided. In other words, the computational inaccuracy due to an overly, roughly chosen base is minimized. Overall, this development leads to the base assuming the smallest possible value that is possible without the risk of an overflow. The precise value of the base Base_(x) may be specified according to this criterion.

In an embodiment of the method, a coded addition +_(c) of two coded variables x_(1c) and x_(2c) is performed in accordance with the following relationship: x _(3c) :=x _(1c)+_(c) x _(2c), where:  Eq. 6 value_(x3):=(value_(x1) *k ₁+value_(x2) *k ₂ +k ₃)/Size_(x3), where the following applies: max_(x3)=max_(x1)+max_(x2) min_(x3)=min_(x1)+min_(x2) Base_(x1)≥(max_(x1)−min_(x1))/Size_(x1) Base_(x2)(max_(x2)−min_(x2))/Size_(x2) Base_(x3)(max_(x3)−min_(x3))/Size_(x3) k ₂ /k ₁Base_(x1)/Base_(x2) k ₁+Base_(x1)/2^(n)≈Base_(x3) k ₂+Base_(x2)/2^(n)≈Base_(x3) and ≈ means that due to rounding errors and processor inaccuracy there is no requirement for any mathematical equality to be present, yet the specified calculation is to be implemented.

In other words, the coded operator +_(c) relating to the addition is defined via the above-cited relationship. Here, calculations in the compiled program are performed only with the values value_(x1), value_(x2) and value_(x3). The constants k₁ and k₂ in this case describe the relations between the bases Base_(x1), Base_(x2) and Base_(x3). The base Base_(x1) is the base of the variable x₁, the base Base_(x2) is the base of the variable x₂, and the base Base_(x3) is the base of the result x₃. The greatest values max_(x1) and max_(x2) predefined in accordance with the control program, as well as the smallest values min_(x1) and min_(x2) predefined in accordance with the control program for the variables x₁ and x₂, are used to form the bases Base_(x1) and Base_(x2). The smallest and the greatest value for x₃ are formed by means of an addition of the greatest and smallest values, respectively, of the variables x₁ and x₂. The constant k₃ may be chosen so as to minimize rounding errors. The bases may be determined via a compiler. The advantage resulting from this is that no base needs to be determined during the runtime of the addition operation. Furthermore, only integers are used during the operation. Separate operations relating to the mantissa and the exponent, as is necessary in the addition of floating-point numbers, and the transformations and normalizations required for this, are therefore unnecessary.

In an embodiment, a coded multiplication *_(c) of two coded variables x_(1c) and x_(2c) is performed in accordance with the following relationship: x _(3c) :=x _(1c)*_(c) x _(2c), where  Eq. 7 value_(x3):=(value_(x1)*value_(x2) +k)/Size_(x3), where the following applies: Base_(x1)≥(max_(x1)−min_(x1))/Size_(x1) Base_(x2)≥(max_(x2)−min_(x2))/Size_(x2) Base_(x3)≥(max_(x3)−min_(x3))/Size_(x3) Base_(x3)≈(Base_(x1)*Base_(x2))/Size_(x3) max_(x3)=MAX(min_(x1)*min_(x2),min_(x1)*max_(x2),max_(x1)*min_(x2),max_(x1)*max_(x2)) min_(x3)=MIN(min_(x1)*min_(x2),min_(x1)*max_(x2),max_(x1)*min_(x2),max_(x1)*max_(x2)).

In other words, a multiplication of the coded variables x_(1c) and x_(2c) is performed via the values value_(x1) and value_(x2). The greatest and smallest product yielded in each case in a multiplication of the greatest possible values max_(x1), max_(x2) and the smallest possible values min_(x1), min_(x2) of x₁ and x₂, respectively, are used as the greatest possible value max_(x3) and as the smallest possible value min_(x3), respectively, of the variable x₃.

In a further embodiment, a value value_(x1) having a base Base_(x1) is recoded to a value value′_(x1) having a base Base′_(x1) in accordance with the following relationship: value′_(x1)=(((value_(x1) +k ₁)/2^(n))*k ₂ +k ₃)/2^(n)′,  Eq. 8 where k ₂/(2^(n) +n′)≈Base_(x)/Base′_(x) and n′ is the bit count of the recoded representation.

In this case, the constants k₁, k₂ and k₃ are chosen so as to minimize the rounding error as a function of k₂.

It is also an object of the invention to provide a data processing system that is configured to perform one of the above-cited methods. In this context, the system may be a microcontroller or a microprocessor, for example.

Other objects and features of the present invention will become apparent from the following detailed description considered in conjunction with the accompanying drawings. It is to be understood, however, that the drawings are designed solely for purposes of illustration and not as a definition of the limits of the invention, for which reference should be made to the appended claims. It should be further understood that the drawings are not necessarily drawn to scale and that, unless otherwise indicated, they are merely intended to conceptually illustrate the structures and procedures described herein.

BRIEF DESCRIPTION OF THE DRAWINGS

An exemplary embodiment of the invention is described below, in which:

FIG. 1 illustrates the execution flow of a coded calculation of a sine value using the described method; and

FIG. 2 is a schematic block diagram of a data processing system in accordance with the invention.

DETAILED DESCRIPTION OF THE EXEMPLARY EMBODIMENTS

The sine value of a functional variable x in degrees may be calculated numerically in a range of 0° inclusive up to and including 45° by means of the following function:

static float sin7pi4(float x){ float a = 9.99999989793669848536e−1; float b = −1.66666423796176028737e−1; float c = 8.33179571459221545387e−3; float d = −1.94842039748219288187e−4; float square = x*x; float tmp1 = square*d; float tmp2 = c + tmp1; float tmp3 = square*tmp2; float tmp4 = (b + tmp3); float tmp5 = square*tmp4; float tmp6 = (a + tmp5); float tmp7 = tmp6*x; return tmp7; }

The function concerns a power series using the constants a, b, c and d. Intermediate steps may be combined here under tmp1-tmp7. The power series may be concluded with tmp7, which can be output at the end of a program (return tmp7). The value square may be the square of the functional variable x. All of the values may be a floating-point number (float).

The above-cited function may be performed in coded form via the method in accordance with the invention. Here, a bit count n of e.g. 49 bits may be made available. The precision of the input may be specified to a thousandth, for example.

With reference to FIG. 1, in a first step P1, the size Size_(x) is calculated. According to the limits of the control program, which may range from 0° inclusive up to and including 45°, a smallest possible value min_(x)=0 and a greatest possible value max_(x)=45000 may be specified in the case of a precision fixed at 1/1000°. The input value is therefore present as an integer. According to the above definitions, this yields:

Size_(x):=2⁴⁹

min_(x):=0

max_(x):=45000

In a second step P2, the square of x is calculated, where a bit count of n=49 bits can be available. The base for calculating a square of x given a bit count of n=49, Base_(x) ₂ _(,n=49), can be calculated from the smallest possible value min_(x) ₂ _(,n=49) and the greatest possible value max_(x) ₂ _(,n=49) of the square. max_(x) ₂ _(,n=49):=max_(x)*max_(x) min_(x) ₂ _(,n=49):=min_(x)*min_(x) Base_(x) ₂ _(,n=49):=(max_(x) ₂ −min_(x) ₂ )/Size_(x) ₂ _(,n=49) value_(x) ₂ _(,n=49):=value_(x)*value_(x)/Base_(x) ₂ _(,n=49) =value_(x)*value_(x)*277999.

In a third step P3, the value value_(x) ₂ _(,n=49) is recoded from the base Base_(x) ₂ _(,n=49) to a base Base_(x) ₂ _(,n=24), which can have a bit count of 24 bits: value_(x) ₂ _(,n=24)=(value_(x) ₂ _(,n=49)+2²⁴)/2²⁵.

In a fourth step P4, the temporary value value_(tmp1) is calculated: value_(tmp1):=(value_(x) ₂ _(,n=49)*value_(d,n=49) +k)/2²⁴

In a fifth step P5, the temporary value value_(tmp2) is calculated: value_(tmp2):=(value_(c,n=49) *k ₁+value_(tmp1,n=49) *k ₂ +k)/2²⁴

In a sixth step P6, the temporary value value_(tmp3) is calculated: value_(tmp3):=(value_(x) ₂ _(,n=24)*value_(tmp2,n=24) +k)/2²⁴

In a seventh step P7, the temporary value value_(tmp4) is calculated: value_(tmp4):=(value_(b,n=24) *k ₁+value_(tmp3,n=24) *k ₂ +k)/2²⁴

In an eighth step P8, the temporary value value_(tmp5) is calculated: value_(tmp5):=(value_(x2,n=24)*value_(tmp4,n=24) +k)/2²⁴

In a ninth step P9, the temporary value value_(tmp6) is calculated: value_(tmp6):=(value_(a,n=24) *k ₁+value_(tmp5,n=24) *k ₂ +k)/2²⁴

In a tenth step P10, the temporary value value_(tmp7) is calculated: value_(tmp7):=(value_(x,n=24)*value_(tmp6,n=24) +k)/2²⁴

In an eleventh step P11, the value z is calculated from the temporary value value_(tmp7) and its base Base_(tmp7): z:=sin(x):=value_(tmp7,n=24)*Base_(tmp7)

In a twelfth step P12, the value value_(z) having a base 2⁻⁴⁹ specified for a return value is calculated from the temporary value value_(tmp7) and its base Base_(tmp7): value_(z):=Base_(tmp7)*Base_(tmp7)/2⁻⁴⁹

In a thirteenth step P13, the value value_(z) is converted into a floating-point number Float_(z). This is advantageous owing to the fact that the base of the value value_(z) is a 2nd power.

A program code could be written in the following manner, for example:

Size:=2⁴⁹

Minimum:=0

Maximum:=45000 square_(val49):=277999*X _(val) *X _(val) square_(val24):=(square_(val49)+2²⁴)/2²⁵ tmp2_(val):=18172496+(−1378477226−squareval49)/2³¹ tmp4_(val):=(square_(val24) *tmp2_(val)+111040616)/2−18415894 tmp6_(val):=(square_(va124) *tmp4_(val)−197673)/2¹⁸+11464190094 tmp7_(val):=(tmp6_(val) *x _(val)+2²²)/2²³ tmp7_(bas):=1.277097000028899636e−8 z:=SIN(x):=tmp7_(val)*1.277097000028899636e−8 Desired base for z: 2⁻⁴⁹ Z _(val) :=tmp7_(bas)*7189417

Overall, the example demonstrates how, via the invention, a representation of data is provided that allows a flexible and efficient processing of ANBD-encoded data.

FIG. 2 is schematic block diagram of a data processing system 200 in accordance with the invention. Here, the system may comprise memory 210 and a processor 220, such as a microcontroller or a microprocessor, which is configured to implement the method in accordance with the invention. 

What is claimed is:
 1. A method for protecting data in a data memory against an undetected change, comprising: encoding a functional variable x via a value value_(x), an input constant A, an input signature B_(x) and a timestamp D into a coded variable x_(c) in accordance with the relationship: x _(c):=value_(x) *A+B _(x) +D; and normalizing the functional variable x relative to a base Base_(x) to form the integer value value_(x) from said functional variable x to protect the data in the data memory against the undetected change; wherein the value value_(x) is calculated in accordance with the following relationship: value_(x):=(x/Base_(x))mod 2^(Sizex), where Sizex is a size of an available memory.
 2. The method as claimed in claim 1, wherein the functional variable x is encoded during a compilation operation to yield the coded variable x_(c).
 3. The method as claimed in claim 1, wherein the data is provided for a control program and the base Base_(x) is set to a value greater than or equal to a difference between a greatest attainable value max_(x) predefined according to the control program for the value x and a smallest attainable value min_(x) predefined according to the control program, divided by the size of the available memory Size_(x), such that Base_(x)≥(max_(x)−min_(x))/Size_(x).
 4. The method as claimed in claim 1, wherein a coded addition +_(c) of two coded variables x_(1c) and x_(2c) is performed in accordance with the relationship: value_(x3):=(value_(x1) *k ₁+value_(x2) *k ₂ +k ₃)/Size_(x3), where Base_(x3)≥(max_(x3)−min_(x3))/Size_(x3) max_(x3)=max_(x1)+max_(x2) min_(x3)=min_(x1)+min_(x2) k₂/k₁≈Base_(x1)/Base_(x2) k₁+Base_(x1)/2^(n)≈Base_(x3) k₂+Base_(x2)/2^(n)≈Base_(x3).
 5. The method as claimed in claim 1, wherein a coded multiplication *_(c) of two coded variables x_(1c) and x_(2c) is performed in accordance with the relationship: value_(x3):=(value_(x1)*value_(x2) +k)/2^(n), where Base_(x3)≥(max_(x3)−min_(x3))/Size_(x3) Base_(x3)≈(Base_(x1)*Base_(x2))/Size_(x3) max_(x3)=MAX(min_(x1)*min_(x2),min_(x1)*max_(x2), max_(x1)*min_(x2), max_(x1)*max_(x2)) min_(x3)=MIN(min_(x1)*min_(x2),min_(x1)*max_(x2), max_(x1)*min_(x2), max_(x1)*max_(x2)) k₂/k₁≈Base_(x1)/Base_(x2) k₁+Base_(x1)/2^(n)≈Base_(x3) k₂+Base_(x2)/2^(n)≈Base_(x3).
 6. The method as claimed in claim 1, wherein a recoding from a Base_(x) to a base Base′_(x) is performed in accordance with the following relationship: value′_(x1)=(((value_(x1) +k ₁)/2^(n))*k ₂ +k ₃)/2^(n)′, where k₂/(2n+n′)≈Base_(x)/Base′_(x).
 7. A data processing system comprising: a processor; and data memory: wherein the processor is configured to: encode a functional variable x via a value value_(x), an input constant A, an input signature B_(x) and a timestamp D into a coded variable x_(c) in accordance with the relationship: x _(c):=value_(x) *A+B _(x) +D; and normalize the functional variable x relative to a base Base_(x) to form the integer value value_(x) from said functional variable x to protect the data in the data memory against the undetected change; wherein the value value_(x) is calculated in accordance with the following relationship: value_(x):=(x/Base_(x))mod 2^(Sizex), where Sizex is a size of an available memory.
 8. A method for protecting data in a data memory against an undetected change, comprising: encoding a functional variable x via a value value_(x), an input constant A, an input signature B_(x) and a timestamp D into a coded variable x_(c) in accordance with the relationship: x _(c):=value_(x) *A+B _(x) +D; and normalizing the functional variable x relative to a base Base_(x) to form the integer value value_(x) from said functional variable x to protect the data in the data memory against the undetected change; wherein the value value_(x) is calculated in accordance with the following relationship: value_(x):=(x−min_(x)/Base_(x))mod 2^(Sizex), where min_(x) is a predefined minimum value of x. 